<html>
	<head>
		<meta charset="utf-8"/>
		<title>BString</title>
		<link rel="stylesheet" type="text/css" href="../style.css"/>
	</head>
	<body>
		<h1>BString</h1>
		<p>Inherites from <a href="BThing.html">BThing</a></p>
		<h2>public</h2>
		<table id="public">
			<tr><td align="right">class </td><td><a href="#iterator">iterator</a></td></tr>
			<tr><td align="right">class </td><td><a href="#const_iterator">const_iterator</a></td></tr>
			<tr><td align="right">inline </td><td><a href="#BString()">BString</a>();</td></tr>
			<tr><td align="right">inline </td><td><a href="#BString(char,int)">BString</a>(char ch, int size = 1);</td></tr>
			<tr><td align="right">inline </td><td><a href="#BString(const char*)">BString</a>(const char* cstr);</td></tr>
			<tr><td align="right">inline </td><td><a href="#BString(const BString&)">BString</a>(const BString& other);</td></tr>
			<tr><td align="right">inline </td><td><a href="#BString(int)">BString</a>(int number);</td></tr>
			<tr><td align="right">inline </td><td><a href="#BString(unsigned int)">BString</a>(unsigned int number);</td></tr>
			<tr><td align="right">inline </td><td><a href="#BString(long long)">BString</a>(long long number);</td></tr>
			<tr><td align="right">inline </td><td><a href="#BString(unsigned long long)">BString</a>(unsigned long long number);</td></tr>
			<tr><td align="right">inline </td><td><a href="#BString(float,int)">BString</a>(float number, int precision = 8);</td></tr>
			<tr><td align="right">inline </td><td><a href="#BString(double,int)">BString</a>(double number, int precision = 8);</td></tr>
			<tr><td align="right">inline </td><td><a href="#~BString()">~BString</a>();</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#empty()">empty</a>() const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#clear()">clear</a>();</td></tr>
			<tr><td align="right">inline int </td><td><a href="#size()">size</a>() const;</td></tr>
			<tr><td align="right">inline int </td><td><a href="#capacity()">capacity</a>() const;</td></tr>
			<tr><td align="right">inline const char* </td><td><a href="#cstr()">cstr</a>() const;</td></tr>
			<tr><td align="right">inline const char* </td><td><a href="#c_str()">c_str</a>() const;</td></tr>
			<tr><td align="right">inline iterator </td><td><a href="#begin()">begin</a>();</td></tr>
			<tr><td align="right">inline iterator </td><td><a href="#seek(int)">seek</a>(int count);</td></tr>
			<tr><td align="right">inline iterator </td><td><a href="#end()">end</a>();</td></tr>
			<tr><td align="right">inline const_iterator </td><td><a href="#begin()">begin</a>() const;</td></tr>
			<tr><td align="right">inline const_iterator </td><td><a href="#seek(int)">seek</a>(int count) const;</td></tr>
			<tr><td align="right">inline const_iterator </td><td><a href="#end()">end</a>() const;</td></tr>
			<tr><td align="right">inline BCode </td><td><a href="#first()">first</a>() const;</td></tr>
			<tr><td align="right">inline BCode </td><td><a href="#last()">last</a>() const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#isNumber()">isNumber</a>() const;</td></tr>
			<tr><td align="right">inline int </td><td><a href="#toInt(int)">toInt</a>(int def = 0) const;</td></tr>
			<tr><td align="right">inline unsigned int </td><td><a href="#toUInt(unsigned int)">toUInt</a>(unsigned int def = 0);</td></tr>
			<tr><td align="right">inline long long </td><td><a href="#toLong(long long)">toLong</a>(long long def = 0) const;</td></tr>
			<tr><td align="right">inline unsigned long long </td><td><a href="#toULong(unsigned long long)">toULong</a>(unsigned long long def = 0);</td></tr>
			<tr><td align="right">inline float </td><td><a href="#toFloat(float)">toFloat</a>(float def = 0) const;</td></tr>
			<tr><td align="right">inline double </td><td><a href="#toDouble(double)">toDouble</a>(double def = 0) const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#isSequent()">isSequent</a>() const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#isSplit()">isSplit</a>() const;</td></tr>
			<tr><td align="right">inline int </td><td><a href="#word(BString&, int,bool)">word</a>(BString& text, int pos, bool sign = true) const;</td></tr>
			<tr><td align="right">inline BString </td><td><a href="#word(int)">word</a>(int pos) const;</td></tr>
			<tr><td align="right">inline int </td><td><a href="#words(BStringList&)">words</a>(BStringList& strlst) const;</td></tr>
			<tr><td align="right">inline BStringList </td><td><a href="#words()">words</a>() const;</td></tr>
			<tr><td align="right">inline int </td><td><a href="#line(BString&, int,bool)">line</a>(BString& text, int pos, bool eol = false) const;</td></tr>
			<tr><td align="right">inline BString </td><td><a href="#line(int,bool)">line</a>(int pos, bool eol = false) const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#substr(BString&, int,int)">substr</a>(BString& text, int pos, int end = -1) const;</td></tr>
			<tr><td align="right">inline BString </td><td><a href="#substr(int,int)">substr</a>(int pos, int stop = -1) const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#path(BString&)">path</a>(BString& text) const;</td></tr>
			<tr><td align="right">inline BString </td><td><a href="#path()">path</a>() const;</td></tr>
			<tr><td align="right">inline const char* </td><td><a href="#name()">name</a>() const;</td></tr>
			<tr><td align="right">inline const char* </td><td><a href="#ext()">ext</a>() const;</td></tr>
			<tr><td align="right">inline void </td><td><a href="#reverse()">reverse</a>();</td></tr>
			<tr><td align="right">inline void </td><td><a href="#trimmed()">trimmed</a>();</td></tr>
			<tr><td align="right">inline void </td><td><a href="#simplify()">simplify</a>();</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#truncate(int,int)">truncate</a>(int pos, int stop = -1);</td></tr>
			<tr><td align="right">inline int </td><td><a href="#split(BStringList&, char)">split</a>(BStringList& strlst, char c) const;</td></tr>
			<tr><td align="right">inline int </td><td><a href="#split(BStringList&, BCode)">split</a>(BStringList& strlst, BCode code) const;</td></tr>
			<tr><td align="right">inline int </td><td><a href="#split(BStringList&, const char*)">split</a>(BStringList& strlst, const char* cstr) const;</td></tr>
			<tr><td align="right">inline int </td><td><a href="#split(BStringList&, const BString&)">split</a>(BStringList& strlst, const BString& str) const;</td></tr>
			<tr><td align="right">inline BStringList </td><td><a href="#split(char)">split</a>(char c) const;</td></tr>
			<tr><td align="right">inline BStringList </td><td><a href="#split(const BCode&)">split</a>(const BCode& code) const;</td></tr>
			<tr><td align="right">inline BStringList </td><td><a href="#split(const char*)">split</a>(const char* cstr) const;</td></tr>
			<tr><td align="right">inline BStringList </td><td><a href="#split(const BString&)">split</a>(const BString& str) const;</td></tr>
			<tr><td align="right">inline int </td><td><a href="#replace(char, const char*)">replace</a>(char c, const char* cstr);</td></tr>
			<tr><td align="right">inline int </td><td><a href="#replace(const char*, char)">replace</a>(const char* cstr, char c);</td></tr>
			<tr><td align="right">inline int </td><td><a href="#replace(char, const BString&)">replace</a>(char c, const BString& newStr);</td></tr>
			<tr><td align="right">inline int </td><td><a href="#replace(const BString&, char)">replace</a>(const BString& str, char c);</td></tr>
			<tr><td align="right">inline int </td><td><a href="#replace(char, char)">replace</a>(char oldChr, char newChr);</td></tr>
			<tr><td align="right">inline int </td><td><a href="#replace(const char*, const char*)">replace</a>(const char* oldStr, const char* newStr);</td></tr>
			<tr><td align="right">inline int </td><td><a href="#replace(const BString&, const BString&)">replace</a>(const BString& oldStr, const BString& newStr);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#beginWith(char)">beginWith</a>(char c) const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#beginWith(const BString&)">beginWith</a>(const BString& str) const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#beginWith(const char*)">beginWith</a>(const char* cstr) const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#endWith(char)">endWith</a>(char c) const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#endWith(const BString&)">endWith</a>(const BString& str) const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#endWith(const char*)">endWith</a>(const char* cstr) const;</td></tr>
			<tr><td align="right">inline void </td><td><a href="#lower(int,int)">lower</a>(int pos = 0, int count = -1);</td></tr>
			<tr><td align="right">inline void </td><td><a href="#upper(int,int)">upper</a>(int pos = 0, int count = -1);</td></tr>
			<tr><td align="right">inline void </td><td><a href="#prepend(const BCode&,int)">prepend</a>(const BCode& code, int count = 1);</td></tr>
			<tr><td align="right">inline void </td><td><a href="#prepend(char,int)">prepend</a>(char c, int count = 1);</td></tr>
			<tr><td align="right">inline void </td><td><a href="#prepend(const char*)">prepend</a>(const char* str);</td></tr>
			<tr><td align="right">inline void </td><td><a href="#prepend(const BString&)">prepend</a>(const BString& other);</td></tr>
			<tr><td align="right">inline void </td><td><a href="#prepend(int)">prepend</a>(int number);</td></tr>
			<tr><td align="right">inline void </td><td><a href="#prepend(unsigned int)">prepend</a>(unsigned int number);</td></tr>
			<tr><td align="right">inline void </td><td><a href="#prepend(long long)">prepend</a>(long long number);</td></tr>
			<tr><td align="right">inline void </td><td><a href="#prepend(unsigned long long)">prepend</a>(unsigned long long number);</td></tr>
			<tr><td align="right">inline void </td><td><a href="#prepend(float,int)">prepend</a>(float number, int precision = 8);</td></tr>
			<tr><td align="right">inline void </td><td><a href="#prepend(double,int)">prepend</a>(double number, int precision = 8);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#contain(const BCode&)">contain</a>(const BCode& code) const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#contain(char)">contain</a>(char c) const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#contain(const char*)">contain</a>(const char* str) const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#contain(const BString&)">contain</a>(const BString& other) const;</td></tr>
			<tr><td align="right">inline char& </td><td><a href="#operator[](int)">operator[]</a>(int index) const;</td></tr>
			<tr><td align="right">inline BString& </td><td><a href="#operator = (const BString&)">operator = </a>(const BString& other);</td></tr>
			<tr><td align="right">inline BString </td><td><a href="#operator + (const T&)">operator + </a>(const T& value) const;</td></tr>
			<tr><td align="right">inline BString& </td><td><a href="#operator += (const T&)">operator += </a>(const T& value);</td></tr>
			<tr><td align="right">inline BString </td><td><a href="#operator - (const BString&)">operator - </a>(const BString& tail) const;</td></tr>
			<tr><td align="right">inline BString </td><td><a href="#operator - (const char*)">operator - </a>(const char* tail) const;</td></tr>
			<tr><td align="right">inline BString </td><td><a href="#operator - (char)">operator - </a>(char c) const;</td></tr>
			<tr><td align="right">inline void </td><td><a href="#operator -= (const BString&)">operator -= </a>(const BString& tail);</td></tr>
			<tr><td align="right">inline void </td><td><a href="#operator -= (const char*)">operator -= </a>(const char* tail);</td></tr>
			<tr><td align="right">inline void </td><td><a href="#operator -= (char)">operator -= </a>(char c);</td></tr>
			<tr><td align="right">inline BString& </td><td><a href="#operator << (const T&)">operator << </a>(const T& value);</td></tr>
			<tr><td align="right">inline void </td><td><a href="#operator >> (BString&)">operator >> </a>(BString& other) const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#operator == (char)">operator == </a>(char c) const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#operator == (const char*)">operator == </a>(const char* cstr) const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#operator == (const BString&)">operator == </a>(const BString& other) const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#operator != (char)">operator != </a>(char c) const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#operator != (const char*)">operator != </a>(const char* cstr) const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#operator != (const BString&)">operator != </a>(const BString& other) const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#operator > (const char*)">operator > </a>(const char* cstr) const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#operator > (const BString&)">operator > </a>(const BString& other) const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#operator < (const char*)">operator < </a>(const char* cstr) const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#operator < (const BString&)">operator < </a>(const BString& other) const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#operator >= (const char*)">operator >= </a>(const char* cstr) const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#operator >= (const BString&)">operator >= </a>(const BString& other) const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#operator <= (const char*)">operator <= </a>(const char* cstr) const;</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#operator <= (const BString&)">operator <= </a>(const BString& other) const;</td></tr>
			<tr><td align="right">inline int </td><td><a href="#find(char,int,int)">find</a>(char c, int pos = 0, int stop = -1) const;</td></tr>
			<tr><td align="right">inline int </td><td><a href="#find(const BCode&,int,int)">find</a>(const BCode& code, int pos = 0, int stop = -1) const;</td></tr>
			<tr><td align="right">inline int </td><td><a href="#find(const char*,int,int)">find</a>(const char* cstr, int pos = 0, int stop = -1) const;</td></tr>
			<tr><td align="right">inline int </td><td><a href="#find(const BString&,int,int)">find</a>(const BString& other, int pos = 0, int stop = -1) const;</td></tr>
			<tr><td align="right">inline int </td><td><a href="#rfind(char,int,int)">rfind</a>(char c, int pos = -1, int stop = 0) const;</td></tr>
			<tr><td align="right">inline int </td><td><a href="#rfind(const BCode&,int,int)">rfind</a>(const BCode& code, int pos = -1, int stop = 0) const;</td></tr>
			<tr><td align="right">inline int </td><td><a href="#rfind(const char*,int)">rfind</a>(const char* c, int pos = 0) const;</td></tr>
			<tr><td align="right">inline int </td><td><a href="#rfind(const BString&,int)">rfind</a>(const BString& other, int pos = 0) const;</td></tr>
			<tr><td align="right">inline int </td><td><a href="#count()">count</a>() const;</td></tr>
			<tr><td align="right">inline int </td><td><a href="#count(char,int)">count</a>(char c, int pos = 0) const;</td></tr>
			<tr><td align="right">inline int </td><td><a href="#count(const BCode&,int)">count</a>(const BCode& code, int pos = 0) const;</td></tr>
			<tr><td align="right">inline int </td><td><a href="#count(const char*,int)">count</a>(const char* cstr, int pos = 0) const;</td></tr>
			<tr><td align="right">inline int </td><td><a href="#count(const BString&,int)">count</a>(const BString& other, int pos = 0) const;</td></tr>
			<tr><td align="right">inline void </td><td><a href="#reset()">reset</a>();</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#reset(char,int)">reset</a>(char c, int count = 1);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#reset(const BCode&,int)">reset</a>(const BCode& code, int count = 1);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#reset(const char*,int,int)">reset</a>(const char* cstr, int pos = 0, int stop = -1);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#reset(const BString&,int,int)">reset</a>(const BString& other, int pos = 0, int stop = -1);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#reset(int)">reset</a>(int number);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#reset(unsigned int)">reset</a>(unsigned int number);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#reset(long long)">reset</a>(long long number);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#reset(unsigned long long)">reset</a>(unsigned long long number);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#reset(float,int)">reset</a>(float number, int precision = 8);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#reset(double,int)">reset</a>(double number, int precision = 8);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#append(char,int)">append</a>(char ch, int size = 1);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#append(const BCode&,int)">append</a>(const BCode& code, int size = 1);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#append(const char*,int,int)">append</a>(const char* cstr, int pos = 0, int end = -1);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#append(const BString&,int,int)">append</a>(const BString& other, int pos = 0, int end = -1);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#append(int)">append</a>(int number);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#append(unsigned int)">append</a>(unsigned int number);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#append(long long)">append</a>(long long number);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#append(unsigned long long)">append</a>(unsigned long long number);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#append(float,int)">append</a>(float number, int precision = 8);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#append(double,int)">append</a>(double number, int precision = 8);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#insert(int, char,int)">insert</a>(int pos, char ch, int size = 1);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#insert(int, const BCode&,int)">insert</a>(int pos, const BCode& code, int size = 1);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#insert(int, const char*,int)">insert</a>(int pos, const char* cstr, int count = -1);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#insert(int, const BString&)">insert</a>(int pos, const BString& other);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#insert(int, int)">insert</a>(int pos, int number);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#insert(int, unsigned int)">insert</a>(int pos, unsigned int number);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#insert(int, long long)">insert</a>(int pos, long long number);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#insert(int, unsigned long long)">insert</a>(int pos, unsigned long long number);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#insert(int, float,int)">insert</a>(int pos, float number, int precision = 8);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#insert(int, double,int)">insert</a>(int pos, double number, int precision = 8);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#remove(int,int)">remove</a>(int pos, int count = 1);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#remove(const BCode&,int)">remove</a>(const BCode& code, int pos = 0);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#remove(char,int)">remove</a>(char c, int pos = 0);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#remove(const char*,int)">remove</a>(const char* cstr, int pos = 0);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#remove(const BString&,int)">remove</a>(const BString& str, int pos = 0);</td></tr>
			<tr><td align="right">inline bool </td><td><a href="#remove(iterator&)">remove</a>(iterator& it);</td></tr>
		</table>
		<div id="desc">
			<h2>Detailed Description : </h2>
			<p>BString provides a fixed character string.</p>
			<p>BString stores a string of mutiple codes, BCode is a piece copy of the BString. Code could be UTF-8 or GBK encoding.</p>
			<p>You could use the iterator get by begin() to access each code of the string.</p>
		</div>
		<h2 id="docs">Member Documentation</h2>
		<div id="iterator">
			<h3>class iterator</h3>
			<p>The iterator moves per code, this means ++iterator could move index 1, 2, 3 or 4. Get the code by iterator::code() or directly equals the iterator, eg BCode code = it. You can restore the code value of iterator which means the code of iterator position will be replaced.</p>
		</div>
		<div id="const_iterator">
			<h3>class const_iterator</h3>
			<p>Like iterator you can access the each code in the string, but can't restore the code.</p>
		</div>
		<div id="BString()">
			<h3>inline BString();</h3>
			<p>Constructs a empty string.</p>
		</div>
		<div id="BString(char,int)">
			<h3>inline BString(char ch, int size = 1);</h3>
			<p>Constructs a string initialized with the a character of special size. If ch or size is 0, an empty string is constructed. </p>
		</div>
		<div id="BString(const char*)">
			<h3>inline BString(const char* cstr);</h3>
			<p>Constructs a string initialized with eh cstr.</p>
		</div>
		<div id="BString(const BString&)">
			<h3>inline BString(const BString& other);</h3>
			<p>Constructs a string by coping another string.</p>
		</div>
		<div id="BString(int)">
			<h3>inline BString(int number);</h3>
			<p>Constructs a string of a integer number, eg BString str(123), then the str is "123".</p>
		</div>
		<div id="BString(unsigned int)">
			<h3>inline BString(unsigned int number);</h3>
			<p>Constructs a string of a unsigned int number.</p>
		</div>
		<div id="BString(long long)">
			<h3>inline BString(long long number);</h3>
			<p>Constructs a string of a long long number, I suggest use long substitute for long long in C/C++, because long long is so ugly.</p>
		</div>
		<div id="BString(unsigned long long)">
			<h3>inline BString(unsigned long long number);</h3>
			<p>Constructs a string of unsigned long long number.</p>
		</div>
		<div id="BString(float,int)">
			<h3>inline BString(float number, int precision = 8);</h3>
			<p>Constructs a string equivalent of the float number, formatted according to the specified precision. </p>
		</div>
		<div id="BString(double,int)">
			<h3>inline BString(double number, int precision = 8);</h3>
			<p>Constructs a string equivalent of the double number, formatted according to the specified precision.</p>
		</div>
		<div id="~BString()">
			<h3>inline ~BString();</h3>
			<p>Destroys the string.</p>
		</div>
		<div id="empty()">
			<h3>inline bool empty() const;</h3>
			<p>Checks if the string is empty, which means the size of code is zero but capacity could be quite a lot.</p>
		</div>
		<div id="clear()">
			<h3>inline bool clear();</h3>
			<p>Remove all characters and release the string memory.</p>
		</div>
		<div id="size()">
			<h3>inline int size() const;</h3>
			<p>Get the string bytes size, it equals or less than number of characters in the string.</p>
		</div>
		<div id="capacity()">
			<h3>inline int capacity() const;</h3>
			<p>Get the number of capacity.</p>
		</div>
		<div id="cstr()">
			<h3>inline const char* cstr() const;</h3>
			<p>Get c type str, I like use this on more than c_str().</p>
		</div>
		<div id="c_str()">
			<h3>inline const char* c_str() const;</h3>
			<p>Get c type str of string.</p>
		</div>
		<div id="begin()">
			<h3>inline iterator begin();</h3>
			<p>Get a iterator pointing to the first item in the string.</p>
		</div>
		<div id="seek(int)">
			<h3>inline iterator seek(int count);</h3>
			<p>Get a iterator which moves forward count times.</p>
		</div>
		<div id="end()">
			<h3>inline iterator end();</h3>
			<p>Get a iterator pointing to the end of the string, it's code will be 0 and index is the size of string.</p>
		</div>
		<div id="begin()">
			<h3>inline const_iterator begin() const;</h3>
		</div>
		<div id="seek(int)">
			<h3>inline const_iterator seek(int count) const;</h3>
		</div>
		<div id="end()">
			<h3>inline const_iterator end() const;</h3>
		</div>
		<div id="first()">
			<h3>inline BCode first() const;</h3>
			<p>Get the first code of the string.</p>
		</div>
		<div id="last()">
			<h3>inline BCode last() const;</h3>
			<p>Get the last code of string.</p>
		</div>
		<div id="isNumber()">
			<h3>inline bool isNumber() const;</h3>
			<p>Checks if this string can be converted to a number.</p>
		</div>
		<div id="toInt(int)">
			<h3>inline int toInt(int def = 0) const;</h3>
			<p>Converts this string to an integer number, if fail return the def.</p>
		</div>
		<div id="toUInt(unsigned int)">
			<h3>inline unsigned int toUInt(unsigned int def = 0);</h3>
			<p>Converts this string to an unsigned integer number, if fail return the def.</p>
		</div>
		<div id="toLong(long long)">
			<h3>inline long long toLong(long long def = 0) const;</h3>
			<p>Converts this string to an long integer number, if fail return the def.</p>
		</div>
		<div id="toULong(unsigned long long)">
			<h3>inline unsigned long long toULong(unsigned long long def = 0);</h3>
			<p>Converts this string to an unsigned long integer number, if fail return the def.</p>
		</div>
		<div id="toFloat(float)">
			<h3>inline float toFloat(float def = 0) const;</h3>
			<p>Converts this string to a float number, if fail return the def.</p>
		</div>
		<div id="toDouble(double)">
			<h3>inline double toDouble(double def = 0) const;</h3>
			<p>Converts this string to a double number, if fail return the def.</p>
		</div>
		<div id="isSequent()">
			<h3>inline bool isSequent() const;</h3>
		</div>
		<div id="isSplit()">
			<h3>inline bool isSplit() const;</h3>
		</div>
		<div id="word(BString&, int,bool)">
			<h3>inline int word(BString& text, int pos, bool sign = true) const;</h3>
			<p>Get a word from the pos and return index of the word end. The sign specifies if number could be signed '+' or '-'. </p>
		</div>
		<div id="word(int)">
			<h3>inline BString word(int pos) const;</h3>
			<p/>
		</div>
		<div id="words(BStringList&)">
			<h3>inline int words(BStringList& strlst) const;</h3>
			<p>Splits this string to words.</p>
		</div>
		<div id="words()">
			<h3>inline BStringList words() const;</h3>
			<p>Splits this string to words, it doest one more copy of string list than words(strlst).</p>
		</div>
		<div id="line(BString&, int,bool)">
			<h3>inline int line(BString& text, int pos, bool eol = false) const;</h3>
			<p>Get a line text from pos and return end of line, eol indicates if '\n' will be keep in line text.</p>
		</div>
		<div id="line(int,bool)">
			<h3>inline BString line(int pos, bool eol = false) const;</h3>
			<p>Get a line text from this string, do one more copy of string than line(text, pos, eol).</p>
		</div>
		<div id="substr(BString&, int,int)">
			<h3>inline bool substr(BString& text, int pos, int end = -1) const;</h3>
			<p>Get sub string int range from pos to end, return true if successed.</p>
		</div>
		<div id="substr(int,int)">
			<h3>inline BString substr(int pos, int stop = -1) const;</h3>
			<p>Get sub string in range from pos to end, return the string catched. This does one more copy of the result string than substr(text, pos, stop).</p>
		</div>
		<div id="path(BString&)">
			<h3>inline bool path(BString& text) const;</h3>
			<p>This is convenient method get file path in this string, it sees the string as a file name.</p>
		</div>
		<div id="path()">
			<h3>inline BString path() const;</h3>
			<p>This equals path(text), but does one more copy than path(text).</p>
		</div>
		<div id="name()">
			<h3>inline const char* name() const;</h3>
			<p>This is convenient method to get file name in this string, it sees this string as a file name.</p>
		</div>
		<div id="ext()">
			<h3>inline const char* ext() const;</h3>
			<p>This is convenient method to get file extention, it sees this string as a file name.</p>
		</div>
		<div id="reverse()">
			<h3>inline void reverse();</h3>
			<p>Reverse order of each code, eg "123" to "321".</p>
		</div>
		<div id="trimmed()">
			<h3>inline void trimmed();</h3>
			<p>Removes whitespace from the start and the end. eg "\t\n123 \t\n\n" to "123".</p>
		</div>
		<div id="simplify()">
			<h3>inline void simplify();</h3>
			<p>Replace each sequence of internal whitespace with a single space.</p>
		</div>
		<div id="truncate(int,int)">
			<h3>inline bool truncate(int pos, int stop = -1);</h3>
			<p>Truncate this string from pos to stop, it will drop codes before pos and after stop, capacity does't changed. </p>
		</div>
		<div id="split(BStringList&, char)">
			<h3>inline int split(BStringList& strlst, char c) const;</h3>
			<p>Splits this string into substrings wherever c occurs, result substrings will be put in the strlst, return size of the string list.</p>
		</div>
		<div id="split(BStringList&, BCode)">
			<h3>inline int split(BStringList& strlst, BCode code) const;</h3>
		</div>
		<div id="split(BStringList&, const char*)">
			<h3>inline int split(BStringList& strlst, const char* cstr) const;</h3>
		</div>
		<div id="split(BStringList&, const BString&)">
			<h3>inline int split(BStringList& strlst, const BString& str) const;</h3>
		</div>
		<div id="split(char)">
			<h3>inline BStringList split(char c) const;</h3>
		</div>
		<div id="split(const BCode&)">
			<h3>inline BStringList split(const BCode& code) const;</h3>
		</div>
		<div id="split(const char*)">
			<h3>inline BStringList split(const char* cstr) const;</h3>
		</div>
		<div id="split(const BString&)">
			<h3>inline BStringList split(const BString& str) const;</h3>
		</div>
		<div id="replace(char, const char*)">
			<h3>inline int replace(char c, const char* cstr);</h3>
		</div>
		<div id="replace(const char*, char)">
			<h3>inline int replace(const char* cstr, char c);</h3>
		</div>
		<div id="replace(char, const BString&)">
			<h3>inline int replace(char c, const BString& newStr);</h3>
		</div>
		<div id="replace(const BString&, char)">
			<h3>inline int replace(const BString& str, char c);</h3>
		</div>
		<div id="replace(char, char)">
			<h3>inline int replace(char oldChr, char newChr);</h3>
		</div>
		<div id="replace(const char*, const char*)">
			<h3>inline int replace(const char* oldStr, const char* newStr);</h3>
		</div>
		<div id="replace(const BString&, const BString&)">
			<h3>inline int replace(const BString& oldStr, const BString& newStr);</h3>
		</div>
		<div id="beginWith(char)">
			<h3>inline bool beginWith(char c) const;</h3>
		</div>
		<div id="beginWith(const BString&)">
			<h3>inline bool beginWith(const BString& str) const;</h3>
		</div>
		<div id="beginWith(const char*)">
			<h3>inline bool beginWith(const char* cstr) const;</h3>
		</div>
		<div id="endWith(char)">
			<h3>inline bool endWith(char c) const;</h3>
		</div>
		<div id="endWith(const BString&)">
			<h3>inline bool endWith(const BString& str) const;</h3>
		</div>
		<div id="endWith(const char*)">
			<h3>inline bool endWith(const char* cstr) const;</h3>
		</div>
		<div id="lower(int,int)">
			<h3>inline void lower(int pos = 0, int count = -1);</h3>
		</div>
		<div id="upper(int,int)">
			<h3>inline void upper(int pos = 0, int count = -1);</h3>
		</div>
		<div id="prepend(const BCode&,int)">
			<h3>inline void prepend(const BCode& code, int count = 1);</h3>
		</div>
		<div id="prepend(char,int)">
			<h3>inline void prepend(char c, int count = 1);</h3>
		</div>
		<div id="prepend(const char*)">
			<h3>inline void prepend(const char* str);</h3>
		</div>
		<div id="prepend(const BString&)">
			<h3>inline void prepend(const BString& other);</h3>
		</div>
		<div id="prepend(int)">
			<h3>inline void prepend(int number);</h3>
		</div>
		<div id="prepend(unsigned int)">
			<h3>inline void prepend(unsigned int number);</h3>
		</div>
		<div id="prepend(long long)">
			<h3>inline void prepend(long long number);</h3>
		</div>
		<div id="prepend(unsigned long long)">
			<h3>inline void prepend(unsigned long long number);</h3>
		</div>
		<div id="prepend(float,int)">
			<h3>inline void prepend(float number, int precision = 8);</h3>
		</div>
		<div id="prepend(double,int)">
			<h3>inline void prepend(double number, int precision = 8);</h3>
		</div>
		<div id="contain(const BCode&)">
			<h3>inline bool contain(const BCode& code) const;</h3>
		</div>
		<div id="contain(char)">
			<h3>inline bool contain(char c) const;</h3>
		</div>
		<div id="contain(const char*)">
			<h3>inline bool contain(const char* str) const;</h3>
		</div>
		<div id="contain(const BString&)">
			<h3>inline bool contain(const BString& other) const;</h3>
		</div>
		<div id="operator[](int)">
			<h3>inline char& operator[](int index) const;</h3>
		</div>
		<div id="operator = (const BString&)">
			<h3>inline BString& operator = (const BString& other);</h3>
		</div>
		<div id="operator + (const T&)">
			<h3>inline BString operator + (const T& value) const;</h3>
		</div>
		<div id="operator += (const T&)">
			<h3>inline BString& operator += (const T& value);</h3>
		</div>
		<div id="operator - (const BString&)">
			<h3>inline BString operator - (const BString& tail) const;</h3>
		</div>
		<div id="operator - (const char*)">
			<h3>inline BString operator - (const char* tail) const;</h3>
		</div>
		<div id="operator - (char)">
			<h3>inline BString operator - (char c) const;</h3>
		</div>
		<div id="operator -= (const BString&)">
			<h3>inline void operator -= (const BString& tail);</h3>
		</div>
		<div id="operator -= (const char*)">
			<h3>inline void operator -= (const char* tail);</h3>
		</div>
		<div id="operator -= (char)">
			<h3>inline void operator -= (char c);</h3>
		</div>
		<div id="operator << (const T&)">
			<h3>inline BString& operator << (const T& value);</h3>
		</div>
		<div id="operator >> (BString&)">
			<h3>inline void operator >> (BString& other) const;</h3>
		</div>
		<div id="operator == (char)">
			<h3>inline bool operator == (char c) const;</h3>
		</div>
		<div id="operator == (const char*)">
			<h3>inline bool operator == (const char* cstr) const;</h3>
		</div>
		<div id="operator == (const BString&)">
			<h3>inline bool operator == (const BString& other) const;</h3>
		</div>
		<div id="operator != (char)">
			<h3>inline bool operator != (char c) const;</h3>
		</div>
		<div id="operator != (const char*)">
			<h3>inline bool operator != (const char* cstr) const;</h3>
		</div>
		<div id="operator != (const BString&)">
			<h3>inline bool operator != (const BString& other) const;</h3>
		</div>
		<div id="operator > (const char*)">
			<h3>inline bool operator > (const char* cstr) const;</h3>
		</div>
		<div id="operator > (const BString&)">
			<h3>inline bool operator > (const BString& other) const;</h3>
		</div>
		<div id="operator < (const char*)">
			<h3>inline bool operator < (const char* cstr) const;</h3>
		</div>
		<div id="operator < (const BString&)">
			<h3>inline bool operator < (const BString& other) const;</h3>
		</div>
		<div id="operator >= (const char*)">
			<h3>inline bool operator >= (const char* cstr) const;</h3>
		</div>
		<div id="operator >= (const BString&)">
			<h3>inline bool operator >= (const BString& other) const;</h3>
		</div>
		<div id="operator <= (const char*)">
			<h3>inline bool operator <= (const char* cstr) const;</h3>
		</div>
		<div id="operator <= (const BString&)">
			<h3>inline bool operator <= (const BString& other) const;</h3>
		</div>
		<div id="find(char,int,int)">
			<h3>inline int find(char c, int pos = 0, int stop = -1) const;</h3>
		</div>
		<div id="find(const BCode&,int,int)">
			<h3>inline int find(const BCode& code, int pos = 0, int stop = -1) const;</h3>
		</div>
		<div id="find(const char*,int,int)">
			<h3>inline int find(const char* cstr, int pos = 0, int stop = -1) const;</h3>
		</div>
		<div id="find(const BString&,int,int)">
			<h3>inline int find(const BString& other, int pos = 0, int stop = -1) const;</h3>
		</div>
		<div id="rfind(char,int,int)">
			<h3>inline int rfind(char c, int pos = -1, int stop = 0) const;</h3>
		</div>
		<div id="rfind(const BCode&,int,int)">
			<h3>inline int rfind(const BCode& code, int pos = -1, int stop = 0) const;</h3>
		</div>
		<div id="rfind(const char*,int)">
			<h3>inline int rfind(const char* c, int pos = 0) const;</h3>
		</div>
		<div id="rfind(const BString&,int)">
			<h3>inline int rfind(const BString& other, int pos = 0) const;</h3>
		</div>
		<div id="count()">
			<h3>inline int count() const;</h3>
		</div>
		<div id="count(char,int)">
			<h3>inline int count(char c, int pos = 0) const;</h3>
		</div>
		<div id="count(const BCode&,int)">
			<h3>inline int count(const BCode& code, int pos = 0) const;</h3>
		</div>
		<div id="count(const char*,int)">
			<h3>inline int count(const char* cstr, int pos = 0) const;</h3>
		</div>
		<div id="count(const BString&,int)">
			<h3>inline int count(const BString& other, int pos = 0) const;</h3>
		</div>
		<div id="reset()">
			<h3>inline void reset();</h3>
		</div>
		<div id="reset(char,int)">
			<h3>inline bool reset(char c, int count = 1);</h3>
		</div>
		<div id="reset(const BCode&,int)">
			<h3>inline bool reset(const BCode& code, int count = 1);</h3>
		</div>
		<div id="reset(const char*,int,int)">
			<h3>inline bool reset(const char* cstr, int pos = 0, int stop = -1);</h3>
		</div>
		<div id="reset(const BString&,int,int)">
			<h3>inline bool reset(const BString& other, int pos = 0, int stop = -1);</h3>
		</div>
		<div id="reset(int)">
			<h3>inline bool reset(int number);</h3>
		</div>
		<div id="reset(unsigned int)">
			<h3>inline bool reset(unsigned int number);</h3>
		</div>
		<div id="reset(long long)">
			<h3>inline bool reset(long long number);</h3>
		</div>
		<div id="reset(unsigned long long)">
			<h3>inline bool reset(unsigned long long number);</h3>
		</div>
		<div id="reset(float,int)">
			<h3>inline bool reset(float number, int precision = 8);</h3>
		</div>
		<div id="reset(double,int)">
			<h3>inline bool reset(double number, int precision = 8);</h3>
		</div>
		<div id="append(char,int)">
			<h3>inline bool append(char ch, int size = 1);</h3>
		</div>
		<div id="append(const BCode&,int)">
			<h3>inline bool append(const BCode& code, int size = 1);</h3>
		</div>
		<div id="append(const char*,int,int)">
			<h3>inline bool append(const char* cstr, int pos = 0, int end = -1);</h3>
		</div>
		<div id="append(const BString&,int,int)">
			<h3>inline bool append(const BString& other, int pos = 0, int end = -1);</h3>
		</div>
		<div id="append(int)">
			<h3>inline bool append(int number);</h3>
		</div>
		<div id="append(unsigned int)">
			<h3>inline bool append(unsigned int number);</h3>
		</div>
		<div id="append(long long)">
			<h3>inline bool append(long long number);</h3>
		</div>
		<div id="append(unsigned long long)">
			<h3>inline bool append(unsigned long long number);</h3>
		</div>
		<div id="append(float,int)">
			<h3>inline bool append(float number, int precision = 8);</h3>
		</div>
		<div id="append(double,int)">
			<h3>inline bool append(double number, int precision = 8);</h3>
		</div>
		<div id="insert(int, char,int)">
			<h3>inline bool insert(int pos, char ch, int size = 1);</h3>
		</div>
		<div id="insert(int, const BCode&,int)">
			<h3>inline bool insert(int pos, const BCode& code, int size = 1);</h3>
		</div>
		<div id="insert(int, const char*,int)">
			<h3>inline bool insert(int pos, const char* cstr, int count = -1);</h3>
		</div>
		<div id="insert(int, const BString&)">
			<h3>inline bool insert(int pos, const BString& other);</h3>
		</div>
		<div id="insert(int, int)">
			<h3>inline bool insert(int pos, int number);</h3>
		</div>
		<div id="insert(int, unsigned int)">
			<h3>inline bool insert(int pos, unsigned int number);</h3>
		</div>
		<div id="insert(int, long long)">
			<h3>inline bool insert(int pos, long long number);</h3>
		</div>
		<div id="insert(int, unsigned long long)">
			<h3>inline bool insert(int pos, unsigned long long number);</h3>
		</div>
		<div id="insert(int, float,int)">
			<h3>inline bool insert(int pos, float number, int precision = 8);</h3>
		</div>
		<div id="insert(int, double,int)">
			<h3>inline bool insert(int pos, double number, int precision = 8);</h3>
		</div>
		<div id="remove(int,int)">
			<h3>inline bool remove(int pos, int count = 1);</h3>
		</div>
		<div id="remove(const BCode&,int)">
			<h3>inline bool remove(const BCode& code, int pos = 0);</h3>
		</div>
		<div id="remove(char,int)">
			<h3>inline bool remove(char c, int pos = 0);</h3>
		</div>
		<div id="remove(const char*,int)">
			<h3>inline bool remove(const char* cstr, int pos = 0);</h3>
		</div>
		<div id="remove(const BString&,int)">
			<h3>inline bool remove(const BString& str, int pos = 0);</h3>
		</div>
		<div id="remove(iterator&)">
			<h3>inline bool remove(iterator& it);</h3>
		</div>
	</body>
</html>